{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Double DQN (DDQN) variant  implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement Double DQN (DDQN) variant of DQN carrying on from `6.a-dqn-pytorch.ipynb`. \n",
    "\n",
    "\n",
    "### Recap\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^{-}$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla \\hat{q}_{w_t}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "### DDQN - Double DQN\n",
    "\n",
    "In DQN (refer equation at the top of this notebook), the target value for $\\hat{q}(s_i,a_i;w_t)$ was given by:\n",
    "\n",
    "$$  Y_{i}^{DQN} =   r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) $$\n",
    "\n",
    "A target network with weights $w^-_t$ was used to find the maximum q-estimate at next state $s_i'$ and the weights of the target network are updated periodically from the agent network (aka online network). The agent/online network weights are denoted as $w_t$ and these weights are learnt as part of training to make agent behavior desirable.\n",
    "\n",
    "In Double DQN (DDQN), as proposed in  [Deep Reinforcement Learning with Double Q-learning](https://arxiv.org/pdf/1509.06461.pdf) , analogous to Double Q-Learning (or DQN specifically), we again use two networks but the target value for $\\hat{q}(s_i,a_i;w_t)$ is now computed in following way:\n",
    "\n",
    "$$  Y_{i}^{DDQN} =  r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_i',\\arg\\max_{a'} \\hat{q}(s_i', a';w_{t});w^{-}_{t})  \\right) $$\n",
    "\n",
    "The online/agent network with weight $w$ ($w_t$ when shown with time index) is used to get the best action in $\\arg\\max\\limits_{a'} \\hat{q}(s_i', a';w_{t})$. And target network with weight $w^-$ ($w_t^-$ when shown with time index) is used for calculating the best action's q-value. Like before, we periodically update target network weights $w^{-}_{t}$ from agent/online network weight $w_{t}$\n",
    "\n",
    "The only change is in how TD_Target and hence td_loss ($\\delta$) is calculated. In other words, only modification is to `compute_td_loss` function. Rest of the code remains same. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Lunar Lander and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=142\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network, We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions    \n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for i in range(n_games):\n",
    "        s,_ = env.reset(seed=seed+i)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy (epsilon greedy) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for i in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset(seed=seed+i)\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Double DQN \n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation: \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_{i}',\\arg\\max_{a'} \\hat{q}(s_{i}', a';w_{t});w^{-}_{t})  \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_i',\\arg\\max_{a'} \\hat{q}(s_i', a';w_{t});w^{-}_{t})  \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla_{w_t} \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',A;w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network. \n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_{i}',\\arg\\max_{a'} \\hat{q}(s_{i}^{'}, a^{'};w_{t});w^{-}_{t}) \\right)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$ \n",
    " w_{t+1} \\leftarrow w_t - \\alpha \\nabla_{w}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_ddqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q_s = agent(states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    q_s_a = q_s[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use agent network (online network)\n",
    "    q_s1 = agent(next_states).detach()\n",
    "\n",
    "    # compute Q argmax(next_states, actions) using predicted next q-values\n",
    "    _,a1max = torch.max(q_s1, dim=1)\n",
    "\n",
    "    #use target network to calculate the q value for best action chosen above\n",
    "    q_s1_target = target_network(next_states)\n",
    "\n",
    "    q_s1_a1max = q_s1_target[range(len(a1max)), a1max]\n",
    "\n",
    "    # compute \"target q-values\" \n",
    "    target_q = rewards + gamma * q_s1_a1max * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((q_s_a - target_q).pow(2))\n",
    "\n",
    "    return loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DDQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train agent function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _  = env.reset(seed=seed)\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean return per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 25 * 10**3\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 25001/25001 [02:06<00:00, 197.84it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_ddqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 281.53333333333336\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_b/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_b/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_b/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_b/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/7_b/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks using variant  **Double DQN (DDQN)**. We used Replay Buffer. You could try following things to get more familiarity:\n",
    "\n",
    "**TODO for readers**\n",
    "\n",
    "* Try to run this on another environment of your choice from Gymnasium\n",
    "* Try to replace the training with what is available in SB3\n",
    "* Record and upload trained agent to HuggingFace\n",
    "* Add experiment logging using Weights and Biases\n",
    "* Try to do hyperparameter optimization\n",
    "* Create DDQN with Prioritized Replay\n",
    "* Try different numbers of sizes of layers\n",
    "* Make the notebooks more modular where you could choose the agent (DQN vs DDQN) as well as choose replay buffer options (Experience Replay vs Prioritized Experience Replay). \n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
